// 场景配置API服务
// 与dogService保持一致的网络请求方式
import axios from 'axios'
import ImageUrlManager from '@/utils/imageUtils'

class SceneService {
  
  /**
   * 获取场景模板列表 (简化接口)
   * @returns {Promise<Object>} API响应
   */
  static async getSceneTemplates() {
    try {
      const response = await axios.get('/api/scenes/check')

      if (response.data && response.data.code === 200) {
        // 转换后端数据结构为前端期望的数组格式
        const backendData = response.data.data
        const convertedData = this.convertBackendDataToSceneArray(backendData)

        return {
          success: true,
          data: convertedData,
          message: response.data.message || '获取成功'
        }
      } else {
        return {
          success: false,
          message: response.data?.message || '获取场景数据失败'
        }
      }
    } catch (error) {
      console.error('获取场景数据失败:', error)
      return {
        success: false,
        message: error.message || '网络请求失败'
      }
    }
  }

  /**
   * 转换后端数据结构为前端期望的场景数组
   * @param {Object} backendData - 后端返回的数据
   * @returns {Array} 场景数组
   */
  static convertBackendDataToSceneArray(backendData) {
    if (!backendData) {
      console.warn('后端数据为空，使用模拟数据')
      return this.generateMockData()
    }

    console.log('后端返回的原始数据:', backendData)

    // 将后端的对象结构转换为前端期望的数组结构
    const scenes = [
      {
        id: 1,
        userId: backendData.userId,
        sceneType: "LIVING_ROOM",
        sceneName: "客厅",
        sceneImage: backendData.livingRoomImage || null,
        isDefault: !backendData.isCustom
      },
      {
        id: 2,
        userId: backendData.userId,
        sceneType: "KITCHEN",
        sceneName: "厨房",
        sceneImage: backendData.kitchenImage || null,
        isDefault: !backendData.isCustom
      },
      {
        id: 3,
        userId: backendData.userId,
        sceneType: "BEDROOM",
        sceneName: "卧室",
        sceneImage: backendData.bedroomImage || null,
        isDefault: !backendData.isCustom
      },
      {
        id: 4,
        userId: backendData.userId,
        sceneType: "ENTRANCE",
        sceneName: "门口",
        sceneImage: backendData.entranceImage || null,
        isDefault: !backendData.isCustom
      }
    ]

    // 转换图片URL
    const convertedScenes = scenes.map(scene => {
      if (scene.sceneImage) {
        scene.sceneImage = ImageUrlManager.transformImageUrl(scene.sceneImage)
      }
      return scene
    })

    console.log('转换后的场景数据:', convertedScenes)
    return convertedScenes
  }

  /**
   * 更新场景模板 (与狗狗管理接口风格一致)
   * @param {number} id - 场景ID
   * @param {Object} sceneData - 场景数据
   * @returns {Promise<Object>} API响应
   */
  static async updateSceneTemplate(id, sceneData) {
    try {
      const response = await axios.put(`/api/scenes/templates/${id}`, sceneData)

      if (response.data && response.data.code === 200) {
        return {
          success: true,
          data: response.data.data,
          message: response.data.message || '更新成功'
        }
      } else {
        return {
          success: false,
          message: response.data?.message || '更新场景失败'
        }
      }
    } catch (error) {
      console.error('更新场景失败:', error)
      return {
        success: false,
        message: error.message || '网络请求失败'
      }
    }
  }

  /**
   * 编辑默认场景模板 (上传原始文件)
   * @param {File} file - 场景图片文件
   * @param {string} sceneType - 场景类型 (LIVING_ROOM, KITCHEN, BEDROOM, ENTRANCE)
   * @returns {Promise<Object>} API响应
   */
  static async editDefaultTemplate(file, sceneType) {
    try {
      // 验证文件
      const fileValidation = this.validateImageFile(file)
      if (!fileValidation.valid) {
        return {
          success: false,
          message: fileValidation.message
        }
      }

      // 验证场景类型
      const typeValidation = this.validateSceneType(sceneType)
      if (!typeValidation.valid) {
        return {
          success: false,
          message: typeValidation.message
        }
      }

      // 创建FormData - 直接上传原始文件
      const formData = new FormData()
      formData.append('file', file)
      formData.append('sceneType', sceneType)

      console.log('上传场景文件信息:', {
        name: file.name,
        size: file.size,
        type: file.type,
        sceneType: sceneType
      })

      const response = await axios.post('/api/scenes/edit-default', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        },
        timeout: 30000 // 30秒超时
      })

      console.log('场景上传响应:', response.data)

      if (response.data && response.data.code === 200) {
        return {
          success: true,
          data: response.data.data,
          message: response.data.message || '场景更新成功'
        }
      } else {
        return {
          success: false,
          message: response.data?.message || '场景更新失败'
        }
      }
    } catch (error) {
      console.error('场景更新失败:', error)
      return this.handleApiError(error, '场景更新失败')
    }
  }





  /**
   * 场景类型映射
   * @returns {Object} 场景类型映射
   */
  static getSceneTypeMapping() {
    return {
      'LIVING_ROOM': '客厅',
      'KITCHEN': '厨房',
      'BEDROOM': '卧室',
      'ENTRANCE': '门口'
    }
  }

  /**
   * 验证场景类型
   * @param {string} sceneType - 场景类型
   * @returns {Object} 验证结果
   */
  static validateSceneType(sceneType) {
    const validTypes = Object.keys(this.getSceneTypeMapping())

    if (!sceneType || typeof sceneType !== 'string') {
      return {
        valid: false,
        message: '场景类型不能为空'
      }
    }

    if (!validTypes.includes(sceneType)) {
      return {
        valid: false,
        message: `无效的场景类型。支持的类型: ${validTypes.join(', ')}`
      }
    }

    return {
      valid: true,
      message: '场景类型验证通过'
    }
  }

  /**
   * 验证图片文件
   * @param {File} file - 图片文件
   * @returns {Object} 验证结果
   */
  static validateImageFile(file) {
    if (!file) {
      return {
        valid: false,
        message: '请选择要上传的文件'
      }
    }

    // 检查文件类型
    const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp']
    if (!allowedTypes.includes(file.type)) {
      return {
        valid: false,
        message: '文件格式不支持，请选择 JPG、PNG、GIF 或 WebP 格式的图片'
      }
    }

    // 检查文件大小 (5MB)
    const maxSize = 5 * 1024 * 1024
    if (file.size > maxSize) {
      return {
        valid: false,
        message: '文件大小不能超过 5MB'
      }
    }

    return {
      valid: true,
      message: '文件验证通过'
    }
  }

  /**
   * 获取场景类型显示名称
   * @param {string} sceneType - 场景类型
   * @returns {string} 显示名称
   */
  static getSceneTypeName(sceneType) {
    const mapping = this.getSceneTypeMapping()
    return mapping[sceneType] || sceneType
  }

  /**
   * 验证场景数据
   * @param {Object} sceneData - 场景数据
   * @returns {Object} 验证结果
   */
  static validateSceneData(sceneData) {
    const errors = []

    // 验证必填字段
    if (!sceneData.sceneName || sceneData.sceneName.trim().length === 0) {
      errors.push('场景名称不能为空')
    }

    if (!sceneData.sceneType || sceneData.sceneType.trim().length === 0) {
      errors.push('场景类型不能为空')
    }

    // 验证名称长度
    if (sceneData.sceneName && sceneData.sceneName.length > 50) {
      errors.push('场景名称不能超过50个字符')
    }

    // 验证图片格式
    if (sceneData.sceneImage && !this.isValidImageFormat(sceneData.sceneImage)) {
      errors.push('场景图片格式不正确')
    }

    return {
      isValid: errors.length === 0,
      errors
    }
  }

  /**
   * 验证图片格式
   * @param {string} imageData - 图片数据
   * @returns {boolean} 是否有效
   */
  static isValidImageFormat(imageData) {
    if (!imageData || typeof imageData !== 'string') {
      return false
    }

    // 检查Base64格式
    if (imageData.startsWith('
      return base64Pattern.test(imageData)
    }

    // 检查URL格式
    try {
      new URL(imageData)
      return true
    } catch {
      return false
    }
  }

  /**
   * 生成模拟数据（开发阶段使用）
   * @returns {Array} 模拟场景数据
   */
  static generateMockData() {
    return [
      {
        id: 1,
        userId: null,
        sceneType: "LIVING_ROOM",
        sceneName: "客厅",
        sceneImage: "http://127.0.0.1:9000/game/scenes/default_living_room.jpg",
        isDefault: true
      },
      {
        id: 2,
        userId: null,
        sceneType: "KITCHEN",
        sceneName: "厨房",
        sceneImage: "http://127.0.0.1:9000/game/scenes/default_kitchen.jpg",
        isDefault: true
      },
      {
        id: 3,
        userId: null,
        sceneType: "BEDROOM",
        sceneName: "卧室",
        sceneImage: "http://127.0.0.1:9000/game/scenes/default_bedroom.jpg",
        isDefault: true
      },
      {
        id: 4,
        userId: null,
        sceneType: "ENTRANCE",
        sceneName: "门口",
        sceneImage: "http://127.0.0.1:9000/game/scenes/default_entrance.jpg",
        isDefault: true
      }
    ]
  }

  /**
   * 处理API错误
   * @param {Error} error - 错误对象
   * @param {string} defaultMessage - 默认错误消息
   * @returns {Object} 错误响应
   */
  static handleApiError(error, defaultMessage = '操作失败') {
    console.error('API错误:', error)
    
    if (error.response) {
      // 服务器响应错误
      const message = error.response.data?.message || defaultMessage
      return {
        success: false,
        message,
        status: error.response.status
      }
    } else if (error.request) {
      // 网络错误
      return {
        success: false,
        message: '网络连接失败，请检查网络设置'
      }
    } else {
      // 其他错误
      return {
        success: false,
        message: error.message || defaultMessage
      }
    }
  }
}

export default SceneService
